1class VoteType(Enum):
2    UPVOTE = "UPVOTE"
3    DOWNVOTE = "DOWNVOTE"

1class EventType(Enum):
2    UPVOTE_QUESTION = "UPVOTE_QUESTION"
3    DOWNVOTE_QUESTION = "DOWNVOTE_QUESTION"
4    UPVOTE_ANSWER = "UPVOTE_ANSWER"
5    DOWNVOTE_ANSWER = "DOWNVOTE_ANSWER"
6    ACCEPT_ANSWER = "ACCEPT_ANSWER"

1class User:
2    def __init__(self, name: str):
3        self.id = str(uuid.uuid4())
4        self.name = name
5        self.reputation = 0
6        self._lock = threading.Lock()
7
8    def update_reputation(self, change: int):
9        with self._lock:
10            self.reputation += change
11
12    def get_id(self) -> str:
13        return self.id
14
15    def get_name(self) -> str:
16        return self.name
17
18    def get_reputation(self) -> int:
19        with self._lock:
20            return self.reputation

1class Content(ABC):
2    def __init__(self, content_id: str, body: str, author: User):
3        self.id = content_id
4        self.body = body
5        self.author = author
6        self.creation_time = datetime.now()
7
8    def get_id(self) -> str:
9        return self.id
10
11    def get_body(self) -> str:
12        return self.body
13
14    def get_author(self) -> User:
15        return self.author

1class Post(Content):
2    def __init__(self, post_id: str, body: str, author: User):
3        super().__init__(post_id, body, author)
4        self.vote_count = 0
5        self.voters: Dict[str, VoteType] = {}
6        self.comments: List['Comment'] = []
7        self.observers: List[PostObserver] = []
8        self._lock = threading.Lock()
9
10    def add_observer(self, observer: 'PostObserver'):
11        self.observers.append(observer)
12
13    def notify_observers(self, event: Event):
14        for observer in self.observers:
15            observer.on_post_event(event)
16
17    def vote(self, user: User, vote_type: VoteType):
18        with self._lock:
19            user_id = user.get_id()
20            if self.voters.get(user_id) == vote_type:
21                return  # Already voted
22
23            score_change = 0
24            if user_id in self.voters:  # User is changing their vote
25                score_change = 2 if vote_type == VoteType.UPVOTE else -2
26            else:  # New vote
27                score_change = 1 if vote_type == VoteType.UPVOTE else -1
28
29            self.voters[user_id] = vote_type
30            self.vote_count += score_change
31
32            if isinstance(self, Question):
33                event_type = EventType.UPVOTE_QUESTION if vote_type == VoteType.UPVOTE else EventType.DOWNVOTE_QUESTION
34            else:
35                event_type = EventType.UPVOTE_ANSWER if vote_type == VoteType.UPVOTE else EventType.DOWNVOTE_ANSWER
36
37            self.notify_observers(Event(event_type, user, self))

1class Tag:
2    def __init__(self, name: str):
3        self.name = name
4
5    def get_name(self) -> str:
6        return self.name

1class Question(Post):
2    def __init__(self, title: str, body: str, author: User, tags: Set[Tag]):
3        super().__init__(str(uuid.uuid4()), body, author)
4        self.title = title
5        self.tags = tags
6        self.answers: List['Answer'] = []
7        self.accepted_answer: Optional['Answer'] = None
8
9    def add_answer(self, answer: 'Answer'):
10        self.answers.append(answer)
11
12    def accept_answer(self, answer: 'Answer'):
13        with self._lock:
14            if not self.author.get_id() == answer.get_author().get_id() and self.accepted_answer is None:
15                self.accepted_answer = answer
16                answer.set_accepted(True)
17                self.notify_observers(Event(EventType.ACCEPT_ANSWER, answer.get_author(), answer))
18
19    def get_title(self) -> str:
20        return self.title
21
22    def get_tags(self) -> Set[Tag]:
23        return self.tags
24
25    def get_answers(self) -> List['Answer']:
26        return self.answers

1class Answer(Post):
2    def __init__(self, body: str, author: User):
3        super().__init__(str(uuid.uuid4()), body, author)
4        self.is_accepted = False
5
6    def set_accepted(self, accepted: bool):
7        self.is_accepted = accepted
8
9    def is_accepted_answer(self) -> bool:
10        return self.is_accepted

1class Comment(Content):
2    def __init__(self, body: str, author: User):
3        super().__init__(str(uuid.uuid4()), body, author)

1class Event:
2    def __init__(self, event_type: EventType, actor: User, target_post: 'Post'):
3        self.type = event_type
4        self.actor = actor
5        self.target_post = target_post
6
7    def get_type(self) -> EventType:
8        return self.type
9
10    def get_actor(self) -> User:
11        return self.actor
12
13    def get_target_post(self) -> 'Post':
14        return self.target_post

1class PostObserver(ABC):
2    @abstractmethod
3    def on_post_event(self, event: 'Event'):
4        pass

1class ReputationManager(PostObserver):
2    QUESTION_UPVOTE_REP = 5
3    ANSWER_UPVOTE_REP = 10
4    ACCEPTED_ANSWER_REP = 15
5    DOWNVOTE_REP_PENALTY = -1  # Penalty for the voter
6    POST_DOWNVOTED_REP_PENALTY = -2  # Penalty for the post author
7
8    def on_post_event(self, event: Event):
9        post_author = event.get_target_post().get_author()
10        
11        if event.get_type() == EventType.UPVOTE_QUESTION:
12            post_author.update_reputation(self.QUESTION_UPVOTE_REP)
13        elif event.get_type() == EventType.DOWNVOTE_QUESTION:
14            post_author.update_reputation(self.DOWNVOTE_REP_PENALTY)
15            event.get_actor().update_reputation(self.POST_DOWNVOTED_REP_PENALTY)  # voter penalty
16        elif event.get_type() == EventType.UPVOTE_ANSWER:
17            post_author.update_reputation(self.ANSWER_UPVOTE_REP)
18        elif event.get_type() == EventType.DOWNVOTE_ANSWER:
19            post_author.update_reputation(self.DOWNVOTE_REP_PENALTY)
20            event.get_actor().update_reputation(self.POST_DOWNVOTED_REP_PENALTY)
21        elif event.get_type() == EventType.ACCEPT_ANSWER:
22            post_author.update_reputation(self.ACCEPTED_ANSWER_REP)

1class SearchStrategy(ABC):
2    @abstractmethod
3    def filter(self, questions: List[Question]) -> List[Question]:
4        pass
5
6class KeywordSearchStrategy(SearchStrategy):
7    def __init__(self, keyword: str):
8        self.keyword = keyword.lower()
9
10    def filter(self, questions: List[Question]) -> List[Question]:
11        return [q for q in questions 
12                if self.keyword in q.get_title().lower() or self.keyword in q.get_body().lower()]
13
14class TagSearchStrategy(SearchStrategy):
15    def __init__(self, tag: Tag):
16        self.tag = tag
17
18    def filter(self, questions: List[Question]) -> List[Question]:
19        return [q for q in questions 
20                if any(t.get_name().lower() == self.tag.get_name().lower() for t in q.get_tags())]
21
22class UserSearchStrategy(SearchStrategy):
23    def __init__(self, user: User):
24        self.user = user
25
26    def filter(self, questions: List[Question]) -> List[Question]:
27        return [q for q in questions if q.get_author().get_id() == self.user.get_id()]

1class StackOverflowService:
2    def __init__(self):
3        self.users: Dict[str, User] = {}
4        self.questions: Dict[str, Question] = {}
5        self.answers: Dict[str, Answer] = {}
6        self.reputation_manager = ReputationManager()
7
8    def create_user(self, name: str) -> User:
9        user = User(name)
10        self.users[user.get_id()] = user
11        return user
12
13    def post_question(self, user_id: str, title: str, body: str, tags: Set[Tag]) -> Question:
14        author = self.users[user_id]
15        question = Question(title, body, author, tags)
16        question.add_observer(self.reputation_manager)
17        self.questions[question.get_id()] = question
18        return question
19
20    def post_answer(self, user_id: str, question_id: str, body: str) -> Answer:
21        author = self.users[user_id]
22        question = self.questions[question_id]
23        answer = Answer(body, author)
24        answer.add_observer(self.reputation_manager)
25        question.add_answer(answer)
26        self.answers[answer.get_id()] = answer
27        return answer
28
29    def vote_on_post(self, user_id: str, post_id: str, vote_type: VoteType):
30        user = self.users[user_id]
31        post = self.find_post_by_id(post_id)
32        post.vote(user, vote_type)
33
34    def accept_answer(self, question_id: str, answer_id: str):
35        question = self.questions[question_id]
36        answer = self.answers[answer_id]
37        question.accept_answer(answer)
38
39    def search_questions(self, strategies: List[SearchStrategy]) -> List[Question]:
40        results = list(self.questions.values())
41
42        for strategy in strategies:
43            results = strategy.filter(results)
44
45        return results
46
47    def get_user(self, user_id: str) -> User:
48        return self.users[user_id]
49
50    def find_post_by_id(self, post_id: str) -> Post:
51        if post_id in self.questions:
52            return self.questions[post_id]
53        elif post_id in self.answers:
54            return self.answers[post_id]
55        
56        raise KeyError("Post not found")

1class StackOverflowDemo:
2    @staticmethod
3    def main():
4        service = StackOverflowService()
5
6        # 1. Create Users
7        alice = service.create_user("Alice")
8        bob = service.create_user("Bob")
9        charlie = service.create_user("Charlie")
10
11        # 2. Alice posts a question
12        print("--- Alice posts a question ---")
13        java_tag = Tag("java")
14        design_patterns_tag = Tag("design-patterns")
15        tags = {java_tag, design_patterns_tag}
16        question = service.post_question(alice.get_id(), "How to implement Observer Pattern?", "Details about Observer Pattern...", tags)
17        StackOverflowDemo.print_reputations(alice, bob, charlie)
18
19        # 3. Bob and Charlie post answers
20        print("\n--- Bob and Charlie post answers ---")
21        bob_answer = service.post_answer(bob.get_id(), question.get_id(), "You can use the java.util.Observer interface.")
22        charlie_answer = service.post_answer(charlie.get_id(), question.get_id(), "A better way is to create your own Observer interface.")
23        StackOverflowDemo.print_reputations(alice, bob, charlie)
24
25        # 4. Voting happens
26        print("\n--- Voting Occurs ---")
27        service.vote_on_post(alice.get_id(), question.get_id(), VoteType.UPVOTE)  # Alice upvotes her own question
28        service.vote_on_post(bob.get_id(), charlie_answer.get_id(), VoteType.UPVOTE)  # Bob upvotes Charlie's answer
29        service.vote_on_post(alice.get_id(), bob_answer.get_id(), VoteType.DOWNVOTE)  # Alice downvotes Bob's answer
30        StackOverflowDemo.print_reputations(alice, bob, charlie)
31
32        # 5. Alice accepts Charlie's answer
33        print("\n--- Alice accepts Charlie's answer ---")
34        service.accept_answer(question.get_id(), charlie_answer.get_id())
35        StackOverflowDemo.print_reputations(alice, bob, charlie)
36
37        # 6. Search for questions
38        print("\n--- (C) Combined Search: Questions by 'Alice' with tag 'java' ---")
39        filters_c = [
40            UserSearchStrategy(alice),
41            TagSearchStrategy(java_tag)
42        ]
43        search_results = service.search_questions(filters_c)
44        for q in search_results:
45            print(f"  - Found: {q.get_title()}")
46
47    @staticmethod
48    def print_reputations(*users):
49        print("--- Current Reputations ---")
50        for user in users:
51            print(f"{user.get_name()}: {user.get_reputation()}")
52
53
54if __name__ == "__main__":
55    StackOverflowDemo.main()